/****************************************************************************************************************************************** 
* �ļ�����:	SWM320_spi.c
* ����˵��:	SWM320��Ƭ����SPI����������
* ����֧��:	http://www.synwit.com.cn/e/tool/gbook/?bid=1
* ע������:
* �汾����:	V1.1.0		2017��10��25��
* ������¼:  
*
*
*******************************************************************************************************************************************
* @attention
*
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS WITH CODING INFORMATION 
* REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME. AS A RESULT, SYNWIT SHALL NOT BE HELD LIABLE 
* FOR ANY DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT 
* OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION CONTAINED HEREIN IN CONN-
* -ECTION WITH THEIR PRODUCTS.
*
* COPYRIGHT 2012 Synwit Technology
*******************************************************************************************************************************************/
#include "SWM320.h"
#include "SWM320_spi.h"


/****************************************************************************************************************************************** 
* ��������:	SPI_Init()
* ����˵��:	SPIͬ�����нӿڳ�ʼ��������֡�����趨��ʱ���趨���ٶ��趨���ж��趨��FIFO�����趨
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
*			SPI_InitStructure * initStruct	����SPI����趨ֵ�Ľṹ��
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_Init(SPI_TypeDef * SPIx, SPI_InitStructure * initStruct)
{
	switch((uint32_t)SPIx)
	{
	case ((uint32_t)SPI0):
		SYS->CLKEN |= (0x01 << SYS_CLKEN_SPI0_Pos);
		break;

	case ((uint32_t)SPI1):
		SYS->CLKEN |= (0x01 << SYS_CLKEN_SPI0_Pos);		//��SPI0ʹ��ͬһλʱ��ʹ��
		break;
	}
	
	SPI_Close(SPIx);	//һЩ�ؼ��Ĵ���ֻ����SPI�ر�ʱ����
	
	SPIx->CTRL &= ~(SPI_CTRL_FFS_Msk | SPI_CTRL_CPHA_Msk | SPI_CTRL_CPOL_Msk |
				  SPI_CTRL_SIZE_Msk | SPI_CTRL_MSTR_Msk | SPI_CTRL_CLKDIV_Msk | SPI_CTRL_SSN_H_Msk);
	SPIx->CTRL |= (initStruct->FrameFormat   << SPI_CTRL_FFS_Pos) |
				(initStruct->SampleEdge    << SPI_CTRL_CPHA_Pos) |
				(initStruct->IdleLevel     << SPI_CTRL_CPOL_Pos) |
				((initStruct->WordSize-1)  << SPI_CTRL_SIZE_Pos) |
				(initStruct->Master        << SPI_CTRL_MSTR_Pos) |
				(initStruct->clkDiv        << SPI_CTRL_CLKDIV_Pos) |
				(0                         << SPI_CTRL_SSN_H_Pos);
	
	SPIx->IF = (0x01 << SPI_IF_RFOVF_Pos);	//����жϱ�־
	SPIx->IE &= ~(SPI_IE_RFHF_Msk | SPI_IE_TFHF_Msk | SPI_IE_FTC_Msk);
	SPIx->IE |= (initStruct->RXHFullIEn << SPI_IE_RFHF_Pos) |
				(initStruct->TXEmptyIEn << SPI_IE_TFHF_Pos) |
				(initStruct->TXCompleteIEn << SPI_IE_FTC_Pos);
	
	switch((uint32_t)SPIx)
	{
	case ((uint32_t)SPI0):		
		if(initStruct->RXHFullIEn | initStruct->TXEmptyIEn | initStruct->TXCompleteIEn)
		{
			NVIC_EnableIRQ(SPI0_IRQn);
		}
		else
		{
			NVIC_DisableIRQ(SPI0_IRQn);
		}
		break;
	
	case ((uint32_t)SPI1):		
		if(initStruct->RXHFullIEn | initStruct->TXEmptyIEn | initStruct->TXCompleteIEn)
		{
			NVIC_EnableIRQ(SPI1_IRQn);
		}
		else
		{
			NVIC_DisableIRQ(SPI1_IRQn);
		}
		break;
	}
}

/****************************************************************************************************************************************** 
* ��������:	SPI_Open()
* ����˵��:	SPI�򿪣������շ�
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_Open(SPI_TypeDef * SPIx)
{
	SPIx->CTRL |= (0x01 << SPI_CTRL_EN_Pos);
}

/****************************************************************************************************************************************** 
* ��������:	SPI_Close()
* ����˵��:	SPI�رգ���ֹ�շ�
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_Close(SPI_TypeDef * SPIx)
{
	SPIx->CTRL &= ~SPI_CTRL_EN_Msk;
}

/****************************************************************************************************************************************** 
* ��������:	SPI_Read()
* ����˵��:	��ȡһ������
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: uint32_t				��ȡ��������
* ע������: ��
******************************************************************************************************************************************/
uint32_t SPI_Read(SPI_TypeDef * SPIx)
{
	return SPIx->DATA;
}

/****************************************************************************************************************************************** 
* ��������:	SPI_Write()
* ����˵��:	д��һ������
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
*			uint32_t				Ҫд�������
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_Write(SPI_TypeDef * SPIx, uint32_t data)
{
	SPIx->DATA = data;
}

/****************************************************************************************************************************************** 
* ��������:	SPI_WriteWithWait()
* ����˵��:	д��һ�����ݲ��ȴ�������ȫ���ͳ�ȥ
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1��SPI1
*			uint32_t				Ҫд�������
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_WriteWithWait(SPI_TypeDef * SPIx, uint32_t data)
{
	SPIx->STAT |= (1 << SPI_STAT_WTC_Pos);
	
	SPIx->DATA = data;
	
	while((SPIx->STAT & SPI_STAT_WTC_Msk) == 0);
}

/****************************************************************************************************************************************** 
* ��������: SPI_ReadWrite()
* ����˵��: ����һ�����ݣ������ط��͹����н��յ���
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
*			uint32_t data 			Ҫ���͵�����
* ��    ��: uint32_t				���յ�������
* ע������: ����ͬһ��SPIģ�飬�˺�����Ӧ��SPI_Write()�����ã���ΪSPI_Write()�����SPI_STAT_RFNE״̬
******************************************************************************************************************************************/
uint32_t SPI_ReadWrite(SPI_TypeDef * SPIx, uint32_t data)
{
	SPIx->DATA = data;
	while(!(SPIx->STAT & SPI_STAT_RFNE_Msk));
	
	return SPIx->DATA;
}

/****************************************************************************************************************************************** 
* ��������:	SPI_IsRXEmpty()
* ����˵��:	����FIFO�Ƿ�գ������������Լ���SPI_Read()
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: uint32_t				1 ����FIFO��    0 ����FIFO�ǿ�
* ע������: ��
******************************************************************************************************************************************/
uint32_t SPI_IsRXEmpty(SPI_TypeDef * SPIx)
{
	return (SPIx->STAT & SPI_STAT_RFNE_Msk) ? 0 : 1;
}

/****************************************************************************************************************************************** 
* ��������:	SPI_IsTXFull()
* ����˵��:	����FIFO�Ƿ����������������Լ���SPI_Write()
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: uint32_t				1 ����FIFO��    0 ����FIFO����
* ע������: ��
******************************************************************************************************************************************/
uint32_t SPI_IsTXFull(SPI_TypeDef * SPIx)
{
	return (SPIx->STAT & SPI_STAT_TFNF_Msk) ? 0 : 1;
}

/****************************************************************************************************************************************** 
* ��������:	SPI_IsTXEmpty()
* ����˵��:	����FIFO�Ƿ��
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: uint32_t				1 ����FIFO��    0 ����FIFO�ǿ�
* ע������: ��
******************************************************************************************************************************************/
uint32_t SPI_IsTXEmpty(SPI_TypeDef * SPIx)
{
	return (SPIx->STAT & SPI_STAT_TFE_Msk) ? 1 : 0;
}


/****************************************************************************************************************************************** 
* ��������:	SPI_INTRXHalfFullEn()
* ����˵��:	����FIFO�����ж�ʹ��
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_INTRXHalfFullEn(SPI_TypeDef * SPIx)
{
	SPIx->IE |= (0x01 << SPI_IE_RFHF_Pos);
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTRXHalfFullDis()
* ����˵��:	����FIFO�����жϽ�ֹ
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_INTRXHalfFullDis(SPI_TypeDef * SPIx)
{
	SPIx->IE &= ~(0x01 << SPI_IE_RFHF_Pos);
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTRXHalfFullClr()
* ����˵��:	����FIFO�����жϱ�־���
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_INTRXHalfFullClr(SPI_TypeDef * SPIx)
{
	SPIx->IF = (1 << SPI_IF_RFHF_Pos);
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTRXHalfFullStat()
* ����˵��:	����FIFO�����ж�״̬
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: uint32_t				1 ����FIFO�ﵽ����    0 ����FIFOδ�ﵽ����
* ע������: ��
******************************************************************************************************************************************/
uint32_t SPI_INTRXHalfFullStat(SPI_TypeDef * SPIx)
{
	return (SPIx->IF & SPI_IF_RFHF_Msk) ? 1 : 0;
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTRXFullEn()
* ����˵��:	����FIFO���ж�ʹ��
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_INTRXFullEn(SPI_TypeDef * SPIx)
{
	SPIx->IE |= (0x01 << SPI_IE_RFF_Pos);
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTRXFullDis()
* ����˵��:	����FIFO���жϽ�ֹ
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_INTRXFullDis(SPI_TypeDef * SPIx)
{
	SPIx->IE &= ~(0x01 << SPI_IE_RFF_Pos);
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTRXFullClr()
* ����˵��:	����FIFO���жϱ�־���
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_INTRXFullClr(SPI_TypeDef * SPIx)
{
	SPIx->IF = (1 << SPI_IF_RFF_Pos);
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTRXFullStat()
* ����˵��:	����FIFO���ж�״̬
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: uint32_t				1 ����FIFO��    0 ����FIFOδ��
* ע������: ��
******************************************************************************************************************************************/
uint32_t SPI_INTRXFullStat(SPI_TypeDef * SPIx)
{
	return (SPIx->IF & SPI_IF_RFF_Msk) ? 1 : 0;
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTRXOverflowEn()
* ����˵��:	����FIFO����ж�ʹ��
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_INTRXOverflowEn(SPI_TypeDef * SPIx)
{
	SPIx->IE |= (0x01 << SPI_IE_RFOVF_Pos);
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTRXOverflowDis()
* ����˵��:	����FIFO����жϽ�ֹ
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_INTRXOverflowDis(SPI_TypeDef * SPIx)
{
	SPIx->IE &= ~(0x01 << SPI_IE_RFOVF_Pos);
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTRXOverflowClr()
* ����˵��:	����FIFO����жϱ�־���
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_INTRXOverflowClr(SPI_TypeDef * SPIx)
{
	SPIx->IF = (0x01 << SPI_IF_RFOVF_Pos);
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTRXOverflowStat()
* ����˵��:	����FIFO����ж�״̬
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: uint32_t				1 ����FIFO���    0 ����FIFOδ���
* ע������: ��
******************************************************************************************************************************************/
uint32_t SPI_INTRXOverflowStat(SPI_TypeDef * SPIx)
{
	return (SPIx->IF & SPI_IF_RFOVF_Msk) ? 1 : 0;
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTTXHalfFullEn()
* ����˵��:	����FIFO�����ж�ʹ��
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_INTTXHalfFullEn(SPI_TypeDef * SPIx)
{
	SPIx->IE |= (0x01 << SPI_IE_TFHF_Pos);
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTTXHalfFullDis()
* ����˵��:	����FIFO�����жϽ�ֹ
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_INTTXHalfFullDis(SPI_TypeDef * SPIx)
{
	SPIx->IE &= ~(0x01 << SPI_IE_TFHF_Pos);
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTTXHalfFullClr()
* ����˵��:	����FIFO�����жϱ�־���
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_INTTXHalfFullClr(SPI_TypeDef * SPIx)
{
	SPIx->IF = (1 << SPI_IF_TFHF_Pos);
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTTXHalfFullStat()
* ����˵��:	����FIFO�����ж�״̬
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: uint32_t				1 ����FIFO�ﵽ����    0 ����FIFOδ�ﵽ����
* ע������: ��
******************************************************************************************************************************************/
uint32_t SPI_INTTXHalfFullStat(SPI_TypeDef * SPIx)
{
	return (SPIx->IF & SPI_IF_TFHF_Msk) ? 1 : 0;
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTTXEmptyEn()
* ����˵��:	����FIFO���ж�ʹ��
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_INTTXEmptyEn(SPI_TypeDef * SPIx)
{
	SPIx->IE |= (0x01 << SPI_IE_TFE_Pos);
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTTXEmptyDis()
* ����˵��:	����FIFO���жϽ�ֹ
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_INTTXEmptyDis(SPI_TypeDef * SPIx)
{
	SPIx->IE &= ~(0x01 << SPI_IE_TFE_Pos);
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTTXEmptyClr()
* ����˵��:	����FIFO���жϱ�־���
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_INTTXEmptyClr(SPI_TypeDef * SPIx)
{
	SPIx->IF = (1 << SPI_IF_TFE_Pos);
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTTXEmptyStat()
* ����˵��:	����FIFO���ж�״̬
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: uint32_t				1 ����FIFO��    0 ����FIFO�ǿ�
* ע������: ��
******************************************************************************************************************************************/
uint32_t SPI_INTTXEmptyStat(SPI_TypeDef * SPIx)
{
	return (SPIx->IF & SPI_IF_TFE_Msk) ? 1 : 0;
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTTXCompleteEn()
* ����˵��:	����FIFO���ҷ�����λ�Ĵ������ж�ʹ��
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_INTTXCompleteEn(SPI_TypeDef * SPIx)
{
	SPIx->IE |= (0x01 << SPI_IE_FTC_Pos);
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTTXCompleteDis()
* ����˵��:	����FIFO���ҷ�����λ�Ĵ������жϽ�ֹ
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_INTTXCompleteDis(SPI_TypeDef * SPIx)
{
	SPIx->IE &= ~(0x01 << SPI_IE_FTC_Pos);
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTTXCompleteClr()
* ����˵��:	����FIFO���ҷ�����λ�Ĵ������ж�״̬���
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_INTTXCompleteClr(SPI_TypeDef * SPIx)
{
	SPIx->IF = (1 << SPI_IF_FTC_Pos);
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTTXCompleteStat()
* ����˵��:	����FIFO���ҷ�����λ�Ĵ������ж�״̬
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: uint32_t				1 ����FIFO���ҷ�����λ�Ĵ�����    0 ����FIFO������λ�Ĵ����ǿ�
* ע������: ��
******************************************************************************************************************************************/
uint32_t SPI_INTTXCompleteStat(SPI_TypeDef * SPIx)
{
	return (SPIx->IF & SPI_IF_FTC_Msk) ? 1 : 0;
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTTXWordCompleteEn()
* ����˵��:	����FIFO�ַ�������ж�ʹ��
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_INTTXWordCompleteEn(SPI_TypeDef * SPIx)
{
	SPIx->IE |= (0x01 << SPI_IE_WTC_Pos);
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTTXWordCompleteDis()
* ����˵��:	����FIFO�ַ�������жϽ�ֹ
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_INTTXWordCompleteDis(SPI_TypeDef * SPIx)
{
	SPIx->IE &= ~(0x01 << SPI_IE_WTC_Pos);
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTTXWordCompleteClr()
* ����˵��:	����FIFO�ַ�������жϱ�־���
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: ��
* ע������: ��
******************************************************************************************************************************************/
void SPI_INTTXWordCompleteClr(SPI_TypeDef * SPIx)
{
	SPIx->IF = (1 << SPI_IF_WTC_Pos);
}

/****************************************************************************************************************************************** 
* ��������:	SPI_INTTXWordCompleteStat()
* ����˵��:	����FIFO�ַ�������ж�״̬
* ��    ��: SPI_TypeDef * SPIx		ָ��Ҫ�����õ�SPI����Чֵ����SPI0��SPI1
* ��    ��: uint32_t				1 ��������ж��ѷ���    0 ��������ж�δ����
* ע������: ��
******************************************************************************************************************************************/
uint32_t SPI_INTTXWordCompleteStat(SPI_TypeDef * SPIx)
{
	return (SPIx->IF & SPI_IF_WTC_Msk) ? 1 : 0;
}
